package com.juc.juc_project.other;

import org.springframework.util.CollectionUtils;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
 * Created by fangjicai on 2020/4/7.
 */
public class ConcurrentOneTest {


//    public static void main(String[] args) {
//        Semaphore semaphore = new Semaphore(threadTotal);
//        for (int i=0;i<clientTotal;i++){
//            //循环创建线程对象，模拟并发
//            new Thread(new Runnable() {
//                @Override
//                public void run() {
//                    //使用信号量类控制并发数
//                    try {
//                        //申请资源 如果没有资源，则线程等待
//                        semaphore.acquire();
//                        count++;
//                        System.out.println("count值："+count);
//                        //释放资源
//                        semaphore.release();
//                    }catch (InterruptedException e){
//                        System.out.println(e.getMessage());
//                    }
//                }
//            }).start();
//        }
//
//
//    }
//
//    public static void main(String[] args) throws Exception {
//        //创建信号量类 控制并发数为200
//        Semaphore semaphore = new Semaphore(threadTotal);
//        //创建线程池
//        ExecutorService executorService = Executors.newCachedThreadPool();
//        //实现5000次任务打印完毕后触发
//        CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
//
//        for (int i=0;i<clientTotal;i++){
//            //循环创建线程对象，模拟并发
//            new Thread(new Runnable() {
//                @Override
//                public void run() {
//                    //使用信号量类控制并发数
//                    try {
//                        //申请资源 如果没有资源，则线程等待
//                        semaphore.acquire();
//                        count++;
//                        System.out.println("count值："+count);
//                        //释放资源
//                        semaphore.release();
//                    }catch (InterruptedException e){
//                        System.out.println(e.getMessage());
//                    }
//                    //递减锁进行减一操作
//                    countDownLatch.countDown();
//
//                }
//            }).start();
//        }
//        //等待5000线程执行完毕后触发执行
//        countDownLatch.await();
//        //线程执行完打印count值之后，触发某一个操作
//        System.out.println("count值是："+count+"----触发最后的任务执行");
//
//    }


    //请求总数
    public static  int clientTotal=5000;
    //同时并发的数量
    public static int threadTotal=200;

    //public static Integer count=0;
    public static volatile Integer count=0;
    //public static AtomicInteger count=new AtomicInteger(0);
    //public static LongAdder count=new LongAdder();


    public static void main(String[] args) throws Exception {
        //创建信号量类 控制并发数为200
        Semaphore semaphore = new Semaphore(threadTotal);
        //创建线程池 提高线程资源的复用 减少资源开销
        ExecutorService executorService = Executors.newCachedThreadPool();
        //实现5000次任务打印完毕后触发
        CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i=0;i<clientTotal;i++){
            //循环创建线程对象，模拟并发
            executorService.execute((new Runnable() {
                @Override
                public void run() {
                    //使用信号量类控制并发数
                    try {
                        //申请资源 如果没有资源，则线程等待
                        semaphore.acquire();
                        //增加并获取增加后的变量  count=11 +1
                        //int num = count.incrementAndGet();
                        //count++;
                        count++;
                        //count.increment();//线程安全的自增 cas
                        System.out.println("count值："+count);
                        //System.out.println("count值："+count);
                        //释放资源
                        semaphore.release();
                    }catch (InterruptedException e){
                        System.out.println(e.getMessage());
                    }
                    //递减锁进行减一操作
                    countDownLatch.countDown();

                }
            }));
        }
        //等待5000线程执行完毕后触发执行
        countDownLatch.await();
        //释放线程池资源
        executorService.shutdown();
        //线程执行完打印count值之后，触发某一个操作
        System.out.println("count值是："+count+"----触发最后的任务执行");

    }






}
